﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using ContactManagement.AppCode;
using ContactManagement.AppCode.DynamicDataType;
using ContactManagement.AppCode.DynamicDataType.Creation;
using ContactManagement.Models.DynamicData;
using EFDataModel;
using EFDataModel.Enums;
using Common.Extensions;

namespace ContactManagement.Controllers
{
    /// <summary>
    /// Controller zum Verwalten der dynamischen Eingabefelder
    /// </summary>
    [CustomAuthorize]
    public class DynamicDataController : Controller
    {
        #region Public Views
        /// <summary>
        /// Bearbeiten eines Dynamsichen DateTyps. Hier wird dann automatisch auf den passenden Controller für den aktuellen Datentyp umgeleitet
        /// </summary>
        /// <param name="id">Dynamische DatentypId die bearbeitet werden soll</param>
        public ActionResult DynamicDataTypeEdit(int id)
        {
            //anhand der DynamicDataTypeId den passenden Datentyp finden und auf die Bearbeitenseite für den jeweiligen Typ verweisen
            EFDynamicDataType efDynamicDataType = CurrentHttpContext.GetDataModel().EFDynamicDataTypeMenge.Find(id);
            if (efDynamicDataType != null)
            {
                return RedirectToDynamicDataEdit(efDynamicDataType);
            }

            //Wenn der Datentyp nicht gefunden werden konnte, dann auf die Startseite verweisen und den Fehler anzeigen
            CustomMessage.CurrentMessage(this).AddMessage(App_GlobalResources.SystemMessages.DynamicDatatypeNotFoundRESX, MessageTypes.error);
            return RedirectToAction(EActionHome.Index.ToString(), EControllers.Home.ToString());
        }

        /// <summary>
        /// Anzeigen der im System zur Verfügung stehenden Dynamischen Datentypen
        /// GET: /DynamicData/DynamicDataTypesList
        /// </summary>
        public ActionResult DynamicDataTypesList()
        {
            DynamicDataListModel dynamicDataListModel = new DynamicDataListModel();
            dynamicDataListModel.DynamicDataTypes = (from eDynamicDataType in CurrentHttpContext.GetDataModel().EFDynamicDataTypeMenge.AsNoTracking() select eDynamicDataType).OrderByUrlParams();
            return View(dynamicDataListModel);
        }

        /// <summary>
        /// Anzeigen eines neuen Eintrages für die dynamischen Datentypen
        /// GET: /Administration/DynamicDataTypeAdd
        /// </summary>
        public ActionResult DynamicDataTypeAdd()
        {
            DynamicDataAddModel dynamicDataAddModel = new DynamicDataAddModel();
            return View(dynamicDataAddModel);
        }

        /// <summary>
        /// Erstellen des neuen dynamischen Datentyps, hier werden nur die Basiseinstellungen vorgenommen.
        /// </summary>
        [HttpPost]
        public ActionResult DynamicDataTypeAdd(DynamicDataAddModel model)
        {
            //Prüfen ob auch alle Eingaben richtig sind.
            if (ModelState.IsValid)
            {
                //Laden der Modeldaten und erstellen eines neuen DynamicDataTypes
                EFDynamicDataType efDynamicDataType = new EFDynamicDataType();

                //Standardwerte setzten, fürs Anlegen des DynamicDataType
                efDynamicDataType.CreationDate = DateTime.Now;
                efDynamicDataType.CreatorID = CurrentSession.GetCurrentUser().ID;
                efDynamicDataType.IsSystem = false;
                efDynamicDataType.IsRequired = false;
                efDynamicDataType.RegExString = string.Empty;
                efDynamicDataType.SortId = string.Empty;

                //Kann beim Erstellen auf False gesetzt, da jedes Eingabefeld ohne Gruppen erstellt wird, und damit kann jeder darauf zugreifen,
                //denn wenn keine Gruppen hinterlegt sind hat jeder alle Rechte auf ein dynamisches Eingabefeld.
                efDynamicDataType.IsVisible = false;

                //Daten aus dem Model setzten
                efDynamicDataType.ModuleId = model.ModulId;
                efDynamicDataType.DynamicDataTypeCategoryID = model.DynamicDataTypeCategoryId;
                efDynamicDataType.Name = model.Name;
                efDynamicDataType.DynamicDataTypeId = model.DynamicDataTypeId;

                //Beim erstellen muss z.b. für den Typ EMail, Datum direkt der Regulare Ausdruck gesetzt werden
                if (efDynamicDataType.DynamicDataType == EFDynamicDataTypes.EMail)
                {
                    efDynamicDataType.RegExString = WebConstants.EmailRegularExpString;
                }

                if (efDynamicDataType.DynamicDataType == EFDynamicDataTypes.Datetime)
                {
                    efDynamicDataType.RegExString = WebConstants.DateRegularExpString;
                }


                //Speichern der Einstellungen
                CurrentHttpContext.GetDataModel().EFDynamicDataTypeMenge.Add(efDynamicDataType);
                CurrentHttpContext.GetDataModel().SaveChanges();
                EFDynamicDataType.ResetDynamicDataTypeList();

                //Prüfen ob der Name bereits vergegen, war der angegeben wurde und wenn ja wird eine Warnung im Bearbeiten Fenster ausgegeben
                IsDynamicDataTypeNameAssigned(efDynamicDataType);

                //Auf den EditView verweisen, wenn der Eintrag erfolgreich gespeichert werden konnte
                return RedirectToDynamicDataEdit(efDynamicDataType);
            }

            //Sonst wieder das aktuelle Model anzeigen.
            return View(model);
        }

        /// <summary>
        /// Formular zum Bearbeiten der Gruppenrechte für das Lesen und Schreiben des Dynamischen Eingabefeldes.
        /// </summary>
        /// <param name="id">DynamicDataTypeID die bearbeitet werden soll</param>
        public ActionResult EditGroupRights(int id)
        {
            DynamicDataRights dataRights = new DynamicDataRights(id, new DynamicDataGroupRightsModel(), this);
            return View(dataRights.LoadReadWriteRightsForModel());
        }

        /// <summary>
        /// Zum aktuellen Dynamischen Datentyp die UserGruppe als Lesendes Recht hinzufügen
        /// </summary>
        /// <param name="id">DynamicDataTypeId</param>
        /// <param name="groupId">GruppenId</param>
        public ActionResult AddGroupReadRight(int id, int groupId)
        {
            //Die Gruppe hinzufügen zu den Leserechten für diesen Dynamischen DatenTyp
            DynamicDataRights dataRights = new DynamicDataRights(id, new DynamicDataGroupRightsModel(), this);
            dataRights.AddGroupToReadRights(groupId);

            string dynamicDataTypeId = id.ToString();
            return RedirectToAction(EActionDynamicData.EditGroupRights.ToString(), EControllers.DynamicData.ToString(), new { id = dynamicDataTypeId });
        }

        /// <summary>
        /// Zum aktuellen Dynamischen Datentyp die UserGruppe als Schreibrecht hinzufügen
        /// </summary>
        /// <param name="id">DynamicDataTypeId</param>
        /// <param name="groupId">GruppenId</param>
        public ActionResult AddGroupWriteRight(int id, int groupId)
        {
            //Die Gruppe hinzufügen zu den Leserechten für diesen Dynamischen DatenTyp
            DynamicDataRights dataRights = new DynamicDataRights(id, new DynamicDataGroupRightsModel(), this);
            dataRights.AddGroupToWriteRights(groupId);

            string dynamicDataTypeId = id.ToString();
            return RedirectToAction(EActionDynamicData.EditGroupRights.ToString(), EControllers.DynamicData.ToString(), new { id = dynamicDataTypeId });
        }

        /// <summary>
        /// Aus dem aktuellen Dynamischen Datentyp die UserGruppe als Leserecht entfernen
        /// </summary>
        /// <param name="id">DynamicDataTypeId</param>
        /// <param name="groupId">GruppenId</param>
        public ActionResult DeleteGroupReadRight(int id, int groupId)
        {
            DynamicDataRights dataRights = new DynamicDataRights(id, new DynamicDataGroupRightsModel(), this);
            dataRights.DeleteGroupFromReadRights(groupId);

            string dynamicDataTypeId = id.ToString();
            return RedirectToAction(EActionDynamicData.EditGroupRights.ToString(), EControllers.DynamicData.ToString(), new { id = dynamicDataTypeId });
        }

        /// <summary>
        /// Aus dem aktuellen Dynamischen DatenTyp die Usergruppe als Lese/Schreibrecht entfernen
        /// </summary>
        /// <param name="id">DynamicDataTypeId</param>
        /// <param name="groupId">GruppenId</param>
        public ActionResult DeleteGroupWriteRight(int id, int groupId)
        {
            DynamicDataRights dataRights = new DynamicDataRights(id, new DynamicDataGroupRightsModel(), this);
            dataRights.DeleteGroupFromWriteRights(groupId);

            string dynamicDataTypeId = id.ToString();
            return RedirectToAction(EActionDynamicData.EditGroupRights.ToString(), EControllers.DynamicData.ToString(), new { id = dynamicDataTypeId });
        }

        /// <summary>
        /// Löschen des übergebenen Listeneintrages (wird ermittelt anhand der ListEntryID.
        /// </summary>
        /// <param name="listEntryId">die ListeneintragsId die gelöscht werden soll</param>
        /// <param name="id">Die aktuell Dynamische DatentypId die bearbeitet wird.</param>
        public ActionResult DeleteListEntry(int listEntryId, int id)
        {
            //Der aktuell ausgewählte Listeneintrag, wird im IntegerValue der DynamicData Tabelle gespeichert, daher muss hier nach der ID gesucht werden und ob es sich dabei um einen Listentyp handelt,
            //wenn der Eintrag gefunden werden kann, darf der Listeneintrag nicht entfernt werden, sonst, darf der Eintrag gelöscht werden.
            var count = (from eDynamicData in CurrentHttpContext.GetDataModel().EFDynamicDataMenge
                         where eDynamicData.IntegerValue == listEntryId && eDynamicData.EFDynamicDataType.DynamicDataTypeId == (int)EFDynamicDataTypes.List
                         select eDynamicData.ID).Count();

            //Den Eintrag ermitteln der gelöscht werden soll
            DynamicDataTypeListEntry currentEntry = CurrentHttpContext.GetDataModel().DynamicDataTypeListEntryMenge.Find(listEntryId);

            if (currentEntry != null)
            {
                //wenn kein Eintrag gefunden wurde, kann der Listeneintrag gelöscht werden
                if (count == 0)
                {
                    try
                    {
                        CurrentHttpContext.GetDataModel().DynamicDataTypeListEntryMenge.Remove(currentEntry);
                        CurrentHttpContext.GetDataModel().SaveChanges();
                        EFDynamicDataType.ResetDynamicDataTypeList();
                        CustomMessage.CurrentMessage(this).AddMessage(string.Format(App_GlobalResources.SystemMessages.ListEntryDeletedRESX, currentEntry.Name), MessageTypes.ok);
                    }
                    catch (Exception exception)
                    {
                        EFDebugging.Debugging.WriteLog("Fehler beim Löschen eines Listeneintrags", exception);
                        CustomMessage.CurrentMessage(this).AddMessage(App_GlobalResources.SystemMessages.ErrorPleaseTryAgainRESX, MessageTypes.error);
                    }
                }
                else
                {
                    //Der Eintrag kann nicht gelöscht werden, da hier bereits Werte hinterlegt wurden
                    CustomMessage.CurrentMessage(this).AddMessage(string.Format(App_GlobalResources.SystemMessages.ListEntryInUseRESX, currentEntry.Name), MessageTypes.error);
                }

            }
            else
            {
                //Der Listeneintrag konnte nicht mehr gefunden werden.
                CustomMessage.CurrentMessage(this).AddMessage(App_GlobalResources.SystemMessages.ListEntryNotFoundRESX, MessageTypes.warning);
            }

            //Wieder auf unseren Datentyp verweisen
            string currentId = id.ToString();
            return RedirectToAction(EActionDynamicData.DynamicDataTypeEdit.ToString(), EControllers.DynamicData.ToString(), new { id = currentId });
        }

        /// <summary>
        /// Löschen des übergebenen Dynamischen Datentyps, wenn das Feld nocht nicht verwendet wird.
        /// </summary>
        /// <param name="id">DynamicDataTypeId</param>
        public ActionResult DynamicDataTypeDelete(int id)
        {
            //Laden des datentyps der gelöscht werden soll
            EFDynamicDataType currentDataType = CurrentHttpContext.GetDataModel().EFDynamicDataTypeMenge.Find(id);
            if (currentDataType != null)
            {
                //Prüfen ob der Datentyp bereits verwendet wurde und wenn ja kann dieser nicht mehr gelöscht werden
                //Wird berteits verwendet und kann nicht mehr gelöscht werden
                if (currentDataType.EFDynamicData.Count > 0)
                {
                    //anzeigen der der Datentyp nicht gelöscht werden kann.
                    CustomMessage.CurrentMessage(this).AddMessage(string.Format(App_GlobalResources.SystemMessages.DynamicDataTypeInUseRESX, currentDataType.Name),MessageTypes.warning);       
                }
                else
                {
                    //Löschen des aktuellen Dynamischen Datentyps
                    if (currentDataType.Delete(CurrentHttpContext.GetDataModel()))
                    {
                        CustomMessage.CurrentMessage(this).AddMessage(string.Format(App_GlobalResources.SystemMessages.DynamicDataTypeDeletedRESX, currentDataType.Name), MessageTypes.ok);
                    }
                    else
                    {
                        CustomMessage.CurrentMessage(this).AddMessage(App_GlobalResources.SystemMessages.ErrorPleaseTryAgainRESX, MessageTypes.error);
                    }
                }
            }
            else
            {
                //Der Dynamische Datentyp existiert nicht mehr
                CustomMessage.CurrentMessage(this).AddMessage(App_GlobalResources.SystemMessages.DynamicDatatypeNotFoundRESX, MessageTypes.error);
            }

            return RedirectToAction(EActionDynamicData.DynamicDataTypesList.ToString());
        }
        #endregion

        #region DynamicDataType Bearbeiten/anzeigen
        /// <summary>
        /// Bearbeiten des übergebenen Dynamischen Datentyps (Gilt für String und Textblock)
        /// GET: /DynamicData/DynamicDataTypeEdit/12
        /// </summary>
        /// <param name="id">Die DynamicDataType Id die bearbeitet werden soll</param>
        public ActionResult String(int id)
        {
            //Laden des passenden EditModels für den aktuellen View
            EditModel editModel = (EditModel)LoadModelData(id);
            if (editModel != null)
            {
                return View(editModel);
            }

            //Wenn der Eintrag nicht gefunden werden kann auf den HomeController verweisen
            return RedirectToAction(EActionHome.Index.ToString(), EControllers.Home.ToString());
        }

        /// <summary>
        /// Speichern der bearbeiteten Daten
        /// </summary>
        /// <param name="id">die aktuelle Id</param>
        /// <param name="model">das Datenmodell mit den aktualisierten Daten</param>
        [HttpPost]
        public ActionResult String(int id, EditModel model)
        {

            if (ModelState.IsValid)
            {
                //Speichern der Daten aus dem Model
                SaveModelData(model, id);
                EFDynamicDataType.ResetDynamicDataTypeList();
            }

            return View(model);
        }

        /// <summary>
        /// Bearbeiten des übergebenen Dynamischen Datentyps
        /// </summary>
        public ActionResult Integer(int id)
        {
            //Laden des passenden EditModels für den aktuellen View
            EditModel editModel = (EditModel)LoadModelData(id);
            if (editModel != null)
            {
                return View(editModel);
            }

            //Wenn der Eintrag nicht gefunden werden kann auf den HomeController verweisen
            return RedirectToAction(EActionHome.Index.ToString(), EControllers.Home.ToString());
        }

        /// <summary>
        /// Speichern der bearbeiteten Daten für den Typ Integer
        /// </summary>
        [HttpPost]
        public ActionResult Integer(int id, EditModel model)
        {
            if (ModelState.IsValid)
            {
                //Speichern der Daten aus dem Model
                SaveModelData(model, id);
                EFDynamicDataType.ResetDynamicDataTypeList();
            }

            return View(model);
        }

        /// <summary>
        /// Bearbeiten des übergebenen Dynamischen Datentyps
        /// </summary>
        public ActionResult Email(int id)
        {
            //Laden des passenden EditModels für den aktuellen View
            EditModel editModel = (EditModel)LoadModelData(id);
            if (editModel != null)
            {
                return View(editModel);
            }

            //Wenn der Eintrag nicht gefunden werden kann auf den HomeController verweisen
            return RedirectToAction(EActionHome.Index.ToString(), EControllers.Home.ToString());
        }

        /// <summary>
        /// Speichern der bearbeiteten Daten für den Typ Integer
        /// </summary>
        [HttpPost]
        public ActionResult Email(int id, EditModel model)
        {
            if (ModelState.IsValid)
            {
                //Bei EMail, wird direkt der RegEx Ausdruck hier gesetzt und kann nicht auf der Oberfläche angepasst werden
                model.RegExString = WebConstants.EmailRegularExpString;

                //Speichern der Daten aus dem Model
                SaveModelData(model, id);
                EFDynamicDataType.ResetDynamicDataTypeList();
            }

            return View(model);
        }

        /// <summary>
        /// Bearbeiten des übergebenen Dynamischen Datentyps
        /// </summary>
        public ActionResult Datetime(int id)
        {
            //Laden des passenden EditModels für den aktuellen View
            EditModel editModel = (EditModel)LoadModelData(id);
            if (editModel != null)
            {
                return View(editModel);
            }

            //Wenn der Eintrag nicht gefunden werden kann auf den HomeController verweisen
            return RedirectToAction(EActionHome.Index.ToString(), EControllers.Home.ToString());
        }

        /// <summary>
        /// Speichern der bearbeiteten Daten für den Typ Integer
        /// </summary>
        [HttpPost]
        public ActionResult Datetime(int id, EditModel model)
        {
            if (ModelState.IsValid)
            {
                //Bevor das Model gespeichert wird noch direkt den Regular Expression String für das Datum setzten.
                model.RegExString = WebConstants.DateRegularExpString;

                //Speichern der Daten aus dem Model
                SaveModelData(model, id);
                EFDynamicDataType.ResetDynamicDataTypeList();
            }

            return View(model);
        }

        /// <summary>
        /// Bearbeiten des übergebenen Dynamischen Datentyps
        /// </summary>
        public ActionResult Boolean(int id)
        {
            //Laden des passenden EditModels für den aktuellen View
            EditModel editModel = (EditModel)LoadModelData(id);
            if (editModel != null)
            {
                return View(editModel);
            }

            //Wenn der Eintrag nicht gefunden werden kann auf den HomeController verweisen
            return RedirectToAction(EActionHome.Index.ToString(), EControllers.Home.ToString());
        }

        /// <summary>
        /// Speichern der bearbeiteten Daten für den Typ Integer
        /// </summary>
        [HttpPost]
        public ActionResult Boolean(int id, EditModel model)
        {
            if (ModelState.IsValid)
            {
                //Speichern der Daten aus dem Model
                SaveModelData(model, id);
                EFDynamicDataType.ResetDynamicDataTypeList();
            }

            return View(model);
        }

        /// <summary>
        /// Bearbeiten des übergebenen Dynamischen Datentyps
        /// </summary>
        public ActionResult Decimal(int id)
        {
            //Laden des passenden EditModels für den aktuellen View
            EditModel editModel = (EditModel)LoadModelData(id);
            if (editModel != null)
            {
                return View(editModel);
            }

            //Wenn der Eintrag nicht gefunden werden kann auf den HomeController verweisen
            return RedirectToAction(EActionHome.Index.ToString(), EControllers.Home.ToString());
        }

        /// <summary>
        /// Speichern der bearbeiteten Daten für den Typ Integer
        /// </summary>
        [HttpPost]
        public ActionResult Decimal(int id, EditModel model)
        {
            if (ModelState.IsValid)
            {
                //Speichern der Daten aus dem Model
                SaveModelData(model, id);
                EFDynamicDataType.ResetDynamicDataTypeList();
            }

            return View(model);
        }

        /// <summary>
        /// Bearbeiten des übergebenen Dynamischen Datentyps (List)
        /// </summary>
        public ActionResult List(int id)
        {
            //Laden des passenden EditModels für den aktuellen View
            EditModelList editModel = LoadModelData(id);
            if (editModel != null)
            {
                //Wenn das EditModel erfolgreich geladen werden konnte, dann noch die Listeneinträge laden für die aktuelle Liste
                EFDynamicDataType currentDynamicDataType = CurrentHttpContext.GetDataModel().EFDynamicDataTypeMenge.Find(id);
                editModel.ListEntries = currentDynamicDataType.DynamicDataTypeListEntries.ToList();

                //Einen neuen Eintrag hinzufügen (hier wird nichts angegeben und wenn der User den Eintrag ausfüllt wird dieser auch neu angelegt!
                //um einen weiteren Eintrag anlegen zu können muss der User einfach das Formular abspeichern
                editModel.ListEntries.Add(new DynamicDataTypeListEntry());

                return View(editModel);
            }

            //Wenn der Eintrag nicht gefunden werden kann auf den HomeController verweisen
            return RedirectToAction(EActionHome.Index.ToString(), EControllers.Home.ToString());
        }

        /// <summary>
        /// Speichern der bearbeiteten Daten für den Typ Integer
        /// </summary>
        [HttpPost]
        public ActionResult List(int id, EditModelList model)
        {
            if (ModelState.IsValid)
            {
                //Speichern der Baisdaten aus dem Model und den aktuellen Dynamischen Datentyp nehmen und dann noch die Listeneinträge zu speichern/ändern/hinzufügen
                EFDynamicDataType efDynamicDataType = SaveModelData(model, id);

                if (efDynamicDataType != null)
                {
                    //Speichern der Listeneinträge aus dem Model, Achtung, wenn ein Eintrag 0 ist, dann handelt es sich um den neuen Eintrag, der nur dann gespeichert wird
                    //wenn auch der Name != string.empty ist. Dafür müssen alle Einträge der Liste aus der Oberfläche durchgegangen werden und die Einträge aus dem DynamicDataType aktualisieren.
                    foreach (DynamicDataTypeListEntry eListEntry in model.ListEntries)
                    {
                        //Der Listeneintrag muss neu angelegt werden, aber nur wenn hier auch ein Wert eingetragen wurde, wenn keine Name angegeben wurde, dann wird auch
                        //kein neuer Eintrag angelegt
                        if (eListEntry.ID == 0 && !string.IsNullOrEmpty(eListEntry.Name))
                        {
                            //Erstellen eines neuen Listeneintrages
                            DynamicDataTypeListEntry newEntry = new DynamicDataTypeListEntry()
                                                                    {
                                                                        Name = eListEntry.Name,
                                                                        SortId = eListEntry.SortId
                                                                    };
                            //Den neuen Wert der Liste hinzufügen
                            efDynamicDataType.DynamicDataTypeListEntries.Add(newEntry);
                        }

                        //Es handelt sich um einen bestehenden Eintrag der bearbeitet werden soll.
                        DynamicDataTypeListEntry currentEntry = efDynamicDataType.DynamicDataTypeListEntries.Where(p => p.ID == eListEntry.ID).FirstOrDefault();
                        if (currentEntry != null)
                        {
                            currentEntry.Name = eListEntry.Name;
                            currentEntry.SortId = eListEntry.SortId;
                        }
                    }

                    //Speichern der geänderten Listeneinträge
                    CurrentHttpContext.GetDataModel().SaveChanges();
                    EFDynamicDataType.ResetDynamicDataTypeList();
                }
            }

            //nicht direkt das Model zurückgeben, da wir einen zusätzlichen Leeren Listeneintrag benötigen, der angezeigt werden soll, der im anderen ControllerEintrag bereits erstellt wird.
            //Nicht ganz 100%ig performant aber egal, da es sich nur um die Bearbeiten Funktion für einen Listeneintrag handelt!
            return RedirectToAction(EFDynamicDataTypes.List.ToString(), new { id = model.CurrentDynamicDataType.ID });
        }
        #endregion

        #region Private Functions
        /// <summary>
        /// Es gibt auf der Oberfläche nur einen ControllerEintrag zum Bearbeiten. Denn diese Funktion prüft welcher dynamische Datentyp bearbeitet werden soll
        /// und leitet dann automatisch an den richtigen View weiter.
        /// </summary>
        /// <param name="efDynamicDataType">Der Dynamische Datentyp der bearbeitet werden soll</param>
        private ActionResult RedirectToDynamicDataEdit(EFDynamicDataType efDynamicDataType)
        {
            //Für Textblock und Text gilt der gleiche Controller -> String
            if (efDynamicDataType.DynamicDataType == EFDynamicDataTypes.String || efDynamicDataType.DynamicDataType == EFDynamicDataTypes.Textblock)
            {
                return RedirectToAction(EFDynamicDataTypes.String.ToString(), EControllers.DynamicData.ToString(), new { id = efDynamicDataType.ID });
            }

            //Alle anderen Datentypen haben zum Bearbeiten ihren eigenen Controller, als Name wird dafür der Name aus dem Enum "EFDynamicDataTypes" genommen.
            return RedirectToAction(efDynamicDataType.DynamicDataType.ToString(), EControllers.DynamicData.ToString(), new { id = efDynamicDataType.ID });
        }

        /// <summary>
        /// Setzten der Modeldaten im DynamicDataType der bearbeitet wurde.
        /// </summary>
        /// <param name="model">Das Model aus dem die Daten geladen werden sollen</param>
        /// <param name="efDynamicDataTypeId">DynamicdataTypeId zu der die Daten des Models gespeichert/bearbeitet werden</param>
        private EFDynamicDataType SaveModelData(IEditModel model, int efDynamicDataTypeId)
        {
            //Laden des passenden Dynamic DataTypes, damit dieser mit den modeldaten aktualisiert werden kann
            EFDynamicDataType efDynamicDataType = CurrentHttpContext.GetDataModel().EFDynamicDataTypeMenge.Find(efDynamicDataTypeId);
            if (efDynamicDataType != null)
            {
                efDynamicDataType.Name = model.Name;
                efDynamicDataType.SortId = model.SortId ?? string.Empty;
                efDynamicDataType.RegExString = model.RegExString ?? string.Empty;
                efDynamicDataType.IsRequired = model.IsRequired;
                efDynamicDataType.IsVisible = model.IsVisible;
                efDynamicDataType.CustomCssClass = model.CustomCssClass;
                efDynamicDataType.MinLength = model.MinLength;
                efDynamicDataType.MaxLength = model.MaxLength;
                efDynamicDataType.FormatString = model.FormatString;
                efDynamicDataType.Description = model.Description;
                efDynamicDataType.DynamicDataTypeCategoryID = model.DynamicDataTypeCategoryId;
                efDynamicDataType.IsFilterable = model.IsFilterable;
                CurrentHttpContext.GetDataModel().SaveChanges();

                //Anzeigen das, dass Speichern erfolgreich war
                CustomMessage.CurrentMessage(this).AddMessage(App_GlobalResources.SystemMessages.SaveSuccessfullRESX, MessageTypes.ok);

                //Die Speichern message überschreiben und anzeigen, das der Name doppelt vergeben wurde als Warnung
                IsDynamicDataTypeNameAssigned(efDynamicDataType);

                return efDynamicDataType;
            }
            else
            {
                CustomMessage.CurrentMessage(this).AddMessage(App_GlobalResources.SystemMessages.DynamicDatatypeNotFoundRESX, MessageTypes.error);
            }

            return null;
        }

        /// <summary>
        /// Laden der Modeldaten für den übergebenen dynamicDataType. Es gibt nur Ein ModelType zum Bearbeiten der daten, da diese überall gleich sind
        /// Nur die Oberfläche des Views wird dem entsprechenden Datentyp angepasst.
        /// </summary>
        /// <param name="dynamicDataTypeId">DynamicDataTypeId für die die Modeldaten geladen werden sollen</param>
        private EditModelList LoadModelData(int dynamicDataTypeId)
        {
            //Laden des passenden Dynamic DataTypes, direkt aus der DB und nicht aus unserer Statischen Liste, da dies kein Performanceproblem darstellt.
            EFDynamicDataType efDynamicDataType = CurrentHttpContext.GetDataModel().EFDynamicDataTypeMenge.Find(dynamicDataTypeId);
            if (efDynamicDataType != null)
            {
                //Erstellen eines neuen Models und mit den Daten aus dem DynamicdataType füllen
                EditModelList dataEditModel = new EditModelList();
                dataEditModel.CurrentDynamicDataType = efDynamicDataType;
                dataEditModel.IsRequired = efDynamicDataType.IsRequired;
                dataEditModel.IsVisible = efDynamicDataType.IsVisible;
                dataEditModel.RegExString = efDynamicDataType.RegExString;
                dataEditModel.Name = efDynamicDataType.Name;
                dataEditModel.SortId = efDynamicDataType.SortId;
                dataEditModel.CustomCssClass = efDynamicDataType.CustomCssClass;
                dataEditModel.MinLength = efDynamicDataType.MinLength;
                dataEditModel.MaxLength = efDynamicDataType.MaxLength;
                dataEditModel.FormatString = efDynamicDataType.FormatString;
                dataEditModel.Description = efDynamicDataType.Description;
                dataEditModel.DynamicDataTypeCategoryId = efDynamicDataType.DynamicDataTypeCategoryID;
                dataEditModel.IsFilterable = efDynamicDataType.IsFilterable ?? false;

                //Wenn es sich um einen Listentyp handelt, die Liste mit laden
                if (efDynamicDataType.DynamicDataType == EFDynamicDataTypes.List)
                {
                    dataEditModel.ListEntries = efDynamicDataType.DynamicDataTypeListEntries.ToList();
                }

                return dataEditModel;
            }

            return null;
        }

        /// <summary>
        /// Prüft ob der Name für den dynamischen Datentypen bereits vergeben wurde, für das aktuelle Modul
        /// Wenn ja wird eine Warnung ausgegeben, das der Name bereits vergeben wurde. (ist aber möglich gleiche Namen zu vergeben, sie könnten ja in unterschiedlichen
        /// Kategorien abgelegt sein.
        /// </summary>
        /// <param name="efDynamicDataType">Der Dynamische Datentyp der geprüft werden soll</param>
        /// <returns>TRUE->bereits vergeben | FALSE->Noch nicht vergeben</returns>
        private bool IsDynamicDataTypeNameAssigned(EFDynamicDataType efDynamicDataType)
        {
            //Prüfen ob der gleiche Name im selben Modul noch einmal vergeben wurde und wenn ja wird einfach eine Warnung beim Speichern mit ausgegeben
            var dataTypes = (from eDynamicDataType in CurrentHttpContext.GetDataModel().EFDynamicDataTypeMenge
                             where eDynamicDataType.ModuleId == efDynamicDataType.ModuleId && eDynamicDataType.Name == efDynamicDataType.Name && eDynamicDataType.ID != efDynamicDataType.ID
                             select efDynamicDataType.ID).Count();

            if (dataTypes > 0)
            {
                //Nur eine Warnung ausgeben, das der Name bereit schon einmal vergeben wurde.
                CustomMessage.CurrentMessage(this).AddMessage(App_GlobalResources.SystemMessages.WarningDynamicDataTypeNameExistsRESX, MessageTypes.warning);
                return true;
            }

            return false;
        }
        #endregion
    }
}
